/*
 * @Author jiangzhiwei
 * @Date 2023-07-24 11:19:43
 * @LastEditors jiangzhiwei
 * @LastEditTime 2023-07-31 02:58:11
 * @FilePath \test-cron\src\components\yc-cron\utils\parse.js
 * @Description 解析工具
 */
import dayjs from "dayjs"
import { ERROR, LINUX_TYPE, QUARTS_TYPE, SPRING_TYPE } from "./constant"
import { getDaysByDayOfWeeks, getLastWeekOfMonth, getLatestWeekdayOfMonth, getNthWeekOfMonth } from "./time"

/** 每次查找可匹配时间时的最多查找次数 */
const maxTimes = 100

/**
 * @Author jiangzhiwei
 * @Date 2023-07-24 11:21:16
 * @Description 解析cron表达式
 * @param {string} cron 克隆表达式
 * @param {string} type linux/srping/quarts
 * @return {Array}
 */
export function parseCron (cron, type) {
  const expressionList = Array.apply(undefined, { length: 7 }).map(() => undefined)
  if (cron) {
    const arr = cron.trim().split(' ')
    let offset
    if (type === LINUX_TYPE) {
      offset = 1
    } else {
      offset = 0
    }
    for (let i = 0; i < Math.min(7 - offset, arr.length); i++) {
      expressionList[i + offset] = arr[i]
    }
  }
  return expressionList
}

/** 一些解析表达式所用到的正则 */
const regexpInfos = [
  { type: '-', exp: /^(\d+)-(\d+)$/ },
  { type: '/', exp: /^(\d+|\*)\/(\d+)$/ },
  { type: ',', exp: /^(\d+)(,\d+)*$/ },
  { type: 'NL', exp: /^(\d)L$/ },
  { type: 'NW', exp: /^(\d{1,2})W$/ },
  { type: '#', exp: /^(\d)#(\d)$/ }
]
/**
 * @Author jiangzhiwei
 * @Date 2023-07-25 16:39:44
 * @Description 解析拆分后的表达式
 * @param {string} exp 拆分后的表达式
 * @param {function} 其他规则
 * @return {object | undefined}
 */
function parseExp (exp, otherRule) {
  exp = exp.toUpperCase() // 转大写
  if (exp === '*') {
    return { type: '*' }
  } else if (exp === '?') {
    return { type: '?' }
  } else if (exp === 'L') {
    return { type: 'L' }
  }
  let type
  let expArr
  for (let i = 0; i < regexpInfos.length; i++) {
    const info = regexpInfos[i]
    expArr = info.exp.exec(exp)
    if (expArr) {
      type = info.type
      break
    }
  }
  if (type === '-') {
    return {
      type,
      value: expArr.slice(1).map(item => Number.parseInt(item))
    }
  } else if (type === '/') {
    const num1 = expArr[1] === '*' ? 0 : Number.parseInt(expArr[1])
    const num2 = Number.parseInt(expArr[2])
    return {
      type,
      value: [num1, num2]
    }
  } else if (type === ',') {
    return {
      type,
      value: exp.split(',').map(item => Number.parseInt(item, 10)).sort((a, b) => a - b)
    }
  } else if (type === 'NL') {
    return {
      type,
      value: Number.parseInt(expArr[1])
    }
  } else if (type === 'NW') {
    return {
      type,
      value: Number.parseInt(expArr[1])
    }
  } else if (type === '#') {
    return {
      type,
      value: expArr.slice(1).map(item => Number.parseInt(item))
    }
  }
  if (typeof otherRule === 'function') {
    return otherRule(exp)
  }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-26 15:03:05
 * @Description 获取最近n次执行时间
 * @param {Array} expressionList cron表达式拆分后的数组，一共7个
 * @param {string} type linux/spring/quarts
 * @param {number} n 次数
 * @param {string} formatter 格式化字符串
 * @return {Array} 时间/格式化时间数组
 */
export function getNextActionTimeList (expressionList, type, n, formatter = 'YYYY-MM-DD HH:mm:ss') {
  let time = dayjs()
  // let time = getNextActionTime(now, expressionList, type)
  const result = []
  for (let i = 0; i < n; i++) {
    time = getNextActionTime(time, expressionList, type, i === 0)
    if (time) { // 找到时间
      result.push(time)
    } else { // 没找到时间
      break
    }
  }
  if (formatter) {
    return result.map(item => item.format(formatter))
  } else {
    return result
  }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-26 14:53:50
 * @Description 获取下一次执行时间
 * @param {object} time 指定时间。dayjs对象
 * @param {Array} expressionList cron表达式拆分后的数组，一共7个7
 * @param {boolean} isFirst 是否是第一次比较时间
 * @return {object} 执行时间。dayjs对象
 */
export function getNextActionTime (time, expressionList, type, isFirst) {
  const exps = expressionList.map((item, index) => {
    if (index === 0) { // 秒
      return item || 0 // linux类型没有设置秒，从0秒开始
    } else {
      return item
    }
  })
  time = time.add(1, 'second') // 从下一秒开始
  // ******************* 秒 *******************
  const secondInfo = getNextTime(time, exps, type, 0)
  if (!secondInfo) {
    return undefined
  }
  const t1 = secondInfo.time.format('YYYY-MM-DD HH:mm:ss')
  // ******************* 分钟 *******************
  const minuteInfo = getNextTime(secondInfo.time, exps, type, 1)
  if (!minuteInfo) {
    return undefined
  }
  if (isFirst) {
    let t = minuteInfo.time
    if (time.minute() !== t.minute()) { // 如果分钟数发生了变化，则将前面的值置为最小值
      const minSecond = getValueListByExp(t, exps, type, 0)[0]
      t = t.second(minSecond) // 设置为最小秒
      minuteInfo.time = t
    }
  }
  const t2 = minuteInfo.time.format('YYYY-MM-DD HH:mm:ss')
  // ******************* 小时 *******************
  const hourInfo = getNextTime(minuteInfo.time, exps, type, 2)
  if (!hourInfo) {
    return undefined
  }
  if (isFirst) {
    let t = hourInfo.time
    if (time.hour() !== t.hour()) { // 如果小时数发生了变化，则将前面的值置为最小值
      const minMinute = getValueListByExp(t, exps, type, 1)[0]
      t = t.minute(minMinute) // 设置最小分钟
      const minSecond = getValueListByExp(t, exps, type, 0)[0]
      t = t.second(minSecond) // 设置为最小秒
      hourInfo.time = t
    }
  }
  const t3 = hourInfo.time.format('YYYY-MM-DD HH:mm:ss')
  // ******************* 日 *******************
  let dayInfo
  let dayTypeIndex
  if (exps[3] === '?') { // 如果日没有指定，那么就认为周指定了
    dayTypeIndex = 5
  } else { // 反之，日指定了
    dayTypeIndex = 3
  }
  dayInfo = getNextTime(hourInfo.time, exps, type, dayTypeIndex)
  if (!dayInfo) {
    return undefined
  }
  if (isFirst) {
    let t = dayInfo.time
    if (time.date() !== t.date()) { // 如果日数发生了变化，则将前面的值置为最小值
      const minHour = getValueListByExp(t, exps, type, 2)[0]
      t = t.hour(minHour) // 设置最小小时
      const minMinute = getValueListByExp(t, exps, type, 1)[0]
      t = t.minute(minMinute) // 设置最小分钟
      const minSecond = getValueListByExp(t, exps, type, 0)[0]
      t = t.second(minSecond) // 设置为最小秒
      dayInfo.time = t
    }
  }
  const t4 = dayInfo.time.format('YYYY-MM-DD HH:mm:ss')
  // ******************* 月 *******************
  const monthInfo = getNextTime(dayInfo.time, exps, type, 4)
  if (!monthInfo) {
    return undefined
  }
  if (isFirst) {
    let t = monthInfo.time
    if (time.month() !== t.month()) { // 如果月份发生了变化，则将前面的值置为最小值
      const minDay = getValueListByExp(t, exps, type, dayTypeIndex)[0]
      // 对日的处理。有可能调整月份后，在对应月份中没有满足的日
      if (minDay) { // 找到该月满足条件的最小日
        t = t.date(minDay) // 设置最小日
        const minHour = getValueListByExp(t, exps, type, 2)[0]
        t = t.hour(minHour) // 设置最小小时
        const minMinute = getValueListByExp(t, exps, type, 1)[0]
        t = t.minute(minMinute) // 设置最小分钟
        const minSecond = getValueListByExp(t, exps, type, 0)[0]
        t = t.second(minSecond) // 设置为最小秒
      } else { // 没找到，则找最近的一个时间
        // 因为日会随着月而变化，可能新月份就没有这一天了。所以需要特殊处理
        t = getNextActionTime(t, exps, type, isFirst)
        if (!t) { // 没找到下一个时间
          return undefined
        }
      }
      monthInfo.time = t
    }
  }
  const t5 = monthInfo.time.format('YYYY-MM-DD HH:mm:ss')
  // ******************* 年 *******************
  const yearInfo = getNextTime(monthInfo.time, exps, type, 6)
  if (!yearInfo) {
    return undefined
  }
  if (isFirst) {
    let t = yearInfo.time
    if (time.year() !== t.year()) { // 如果年份发生了变化，则将前面的值置为最小值
      const minMonth = getValueListByExp(t, exps, type, 4)[0]
      t = t.month(minMonth - 1) // 设置最小月份
      const minDay = getValueListByExp(t, exps, type, dayTypeIndex)[0]
      // 对日的处理。有可能调整月份后，在对应月份中没有满足的日
      if (minDay) { // 找到该月满足条件的最小日
        t = t.date(minDay) // 设置最小日
        const minHour = getValueListByExp(t, exps, type, 2)[0]
        t = t.hour(minHour) // 设置最小小时
        const minMinute = getValueListByExp(t, exps, type, 1)[0]
        t = t.minute(minMinute) // 设置最小分钟
        const minSecond = getValueListByExp(t, exps, type, 0)[0]
        t = t.second(minSecond) // 设置为最小秒
      } else { // 没找到，则找最近的一个时间
        t = getNextActionTime(t, exps, type, isFirst)
        if (!t) { // 没找到下一个时间
          return undefined
        }
      }
      yearInfo.time = t
    }
  }
  const t6 = yearInfo.time.format('YYYY-MM-DD HH:mm:ss')
  if (window.debug) {
    console.log([t1, t2, t3, t4, t5, t6])
  } 
  return yearInfo.time
}

const timeTypeInfos = [
  { category: 'second', type: 'second', higherLevel: 'minute' },
  { category: 'minute', type: 'minute', higherLevel: 'hour' },
  { category: 'hour', type: 'hour', higherLevel: 'day' },
  { category: 'day', type: 'date', higherLevel: 'month' },
  { category: 'month', type: 'month', higherLevel: 'year' },
  { category: 'week', type: 'date', higherLevel: 'month' },
  { category: 'year', type: 'year', higherLevel: undefined }
]
/**
 * @Author jiangzhiwei
 * @Date 2023-07-27 11:49:04
 * @Description 获取该级时间的下一次时间
 * @param {object} time 指定时间。dayjs对象
 * @param {Array} expressionList cron表达式拆分后的数组，一共7个
 * @param {string} type linux/spring/quarts
 * @param {number} timeTypeIndex 时间类型序数，依次是秒分时日月周年
 * @param {number} times 该级时间本轮查询次数
 * @return {{ value: number, time: Dayjs } | undefined}
 */
export function getNextTime (time, expressionList, type, timeTypeIndex, times = 0) {
  const exp = expressionList[timeTypeIndex] || '*'
  const timeType = timeTypeInfos[timeTypeIndex].type
  let currValue = time[timeType]()
  if (timeType === 'month') { // dayjs中月份是从0开始的，cron中从1开始
    currValue++ // dayjs -> cron 加1
  }
  /** 满足条件的值 */
  let value
  const info = parseExp(exp)
  const list = getValueList(time, info, type, timeTypeIndex)
  if (!list.length) { // 表示没有找到满足的值
    if (times >= maxTimes) { // 超过100次没有匹配上了
      return undefined
    } else {
      const higherLevel = timeTypeInfos[timeTypeIndex].higherLevel
      if (higherLevel) { // 如果还有更高一级时间
        const newTime = time.add(1, higherLevel) // 高一级时间值加1
        return getNextTime(newTime, expressionList, type, timeTypeIndex, times + 1)
      } else {
        return undefined
      }
    }
  }
  if (currValue > list[list.length - 1]) { // 大于最后一个值
    if (times >= maxTimes) { // 超过100次没有匹配上了
      return undefined
    } else {
      const higherLevel = timeTypeInfos[timeTypeIndex].higherLevel
      if (higherLevel) { // 如果还有更高一级时间
        let newTime = time.add(1, higherLevel) // 高一级时间值加1
        const { min } = getIntervalInfo(newTime, timeTypeIndex)
        let timeValue
        if (timeType === 'month') { // dayjs中月份是从0开始的，cron中从1开始
          timeValue = min - 1 // cron -> dayjs 减1
        } else if (timeType === 'date') { // 日或周所对应
          timeValue = 1 // 最小为1号。这里主要处理周，因为周最小为0
        } else {
          timeValue = min
        }
        newTime = newTime[timeType](timeValue) // 当前级时间置为最小值
        return getNextTime(newTime, expressionList, type, timeTypeIndex, times + 1)
      } else { // 秒分时日月
        return undefined
      }
    }
  } else { // 至少小于等于最后一个值
    list.some(val => {
      if (currValue <= val) {
        value = val
        return true
      }
      return false
    })
  }
  let timeValue
  if (timeType === 'month') { // dayjs中月份是从0开始的，cron中从1开始
    timeValue = value - 1 // cron -> dayjs 减1
  } else {
    timeValue = value
  }
  time = time[timeType](timeValue) // 当前级时间设置为所取值
  return { value, time }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-27 11:11:36
 * @Description 根据表达式获取可取值数组
 * @param {object} time 指定时间。dayjs对象
 * @param {Array} expressionList cron表达式拆分后的数组，一共7个
 * @param {string} type linux/spring/quarts
 * @param {number} timeTypeIndex 时间类型序数，依次是秒分时日月周年
 * @return {Array<number>}
 */
function getValueListByExp (time, expressionList, type, timeTypeIndex) {
  const exp = expressionList[timeTypeIndex] || '*'
  const info = parseExp(exp)
  return getValueList(time, info, type, timeTypeIndex)
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-25 17:29:34
 * @Description 将可能取值转换为值数组。方便后面统一处理
 * @param {object} time 指定时间。dayjs对象
 * @param {object} info 表达式解析后的信息
 * @param {string} type linux/spring/quarts
 * @param {number} timeTypeIndex 时间类型序数，依次是秒分时日月周年
 * @return {Array<number>} 可取值数组
 */
function getValueList (time, info, type, timeTypeIndex) {
  let { min, max, total } = getIntervalInfo(time, timeTypeIndex)
  let length
  if (info.type === '*') {
    length = total
    const list = Array.apply(undefined, { length }).map((item, index) => index + min)
    if (timeTypeIndex === 5) { // 如果是周，则转换为具体天数
      return getDaysByDayOfWeeks(time, list)
    } else {
      return list
    }
  } else if (info.type === '-') {
    let theMin = info.value[0]
    let theMax = info.value[1]
    if (timeTypeIndex === 5) { // 如果是周
      if (type === QUARTS_TYPE) { // quarts是1-7，需要减1
        theMin--
        theMax--
      }
    }
    max = Math.min(max, theMax)
    min = Math.max(min, theMin)
    length = max - min + 1
    const list = Array.apply(undefined, { length }).map((item, index) => index + min)
    if (timeTypeIndex === 5) { // 如果是周，则转换为具体天数
      return getDaysByDayOfWeeks(time, list)
    } else {
      return list
    }
  } else if (info.type === '/') {
    let num = info.value[0]
    if (timeTypeIndex === 5) { // 如果是周
      if (type === QUARTS_TYPE) { // quarts是1-7，需要减1
        num--
      }
    }
    const step = info.value[1]
    const list = []
    while (num <= max) { // 值未超出
      list.push(num)
      num += step
    }
    if (timeTypeIndex === 5) { // 如果是周，则转换为具体天数
      return getDaysByDayOfWeeks(time, list)
    } else {
      return list
    }
  } else if (info.type === ',') {
    if (timeTypeIndex === 5) { // 如果是周，则转换为具体天数
      let list
      if (type === QUARTS_TYPE) { // quarts是1-7，需要减1
        list = info.value.map(num => num - 1)
      } else {
        list = info.value
      }
      return getDaysByDayOfWeeks(time, list)
    } else {
      return info.value.filter(num => num <= max) // 过滤掉超出当前月份的数据
    }
  } else if (info.type === 'L') { // 每月最后一天
    return [max]
  } else if (info.type === 'NL') { // 每月最后一个周几
    const week = type === QUARTS_TYPE ? info.value - 1 : info.value
    return [getLastWeekOfMonth(time, week)]
  } else if (info.type === 'NW') { // 距离每月几号最近的工作日
    const date = getLatestWeekdayOfMonth(time, info.value)
    return date ? [date] : []
  } else if (info.type === '#') { // 第几个星期几
    const nth = info.value[1]
    const week = type === QUARTS_TYPE ? info.value[0] - 1 : info.value[0]
    const date = getNthWeekOfMonth(time, nth, week)
    return date ? [date] : []
  }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-26 19:20:46
 * @Description 获取对应时间类型的值区间
 * @param {object} time 指定时间。dayjs对象
 * @param {number} timeTypeIndex 0-6分别为秒分时日月周年
 * @return {{ min: number, max: number, total: number }}
 */
function getIntervalInfo (time, timeTypeIndex) {
  let min
  let total
  if (timeTypeIndex === 0 || timeTypeIndex === 1) { // 秒或分
    min = 0
    total = 60
  } else if (timeTypeIndex === 2) { // 时
    min = 0
    total = 24
  } else if (timeTypeIndex === 3) { // 如果是日，则转换为具体天数
    min = 1
    total = time.daysInMonth() // 该时间所在月份总天数
  } else if (timeTypeIndex === 4) { // 月
    min = 1
    total = 12
  } else if (timeTypeIndex === 5) { // 周
    min = 0
    total = 7
  } else if (timeTypeIndex === 6) { // 年
    min = dayjs().year() // 从今年开始
    total = 100 // 这里随便写个100年好了
  }
  const max = min + total - 1
  return { min, max, total }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-28 17:23:18
 * @Description 校验正则表达式
 * @param {string} expression 完整的cron表达式
 * @param {'linux' | 'spring' | 'quarts'} type
 * @return {string | undefined} 没有错误信息则返回undefined
 */
export function validateExpression (expression, type) {
  const expressionList = expression.split(' ')
  const len = expressionList.length
  let expList
  const info = {
    valid: true,
    message: undefined,
    index: -1
  }
  // 校验长度
  if (type === LINUX_TYPE) {
    if (len !== 5) {
      info.valid = false
      info.message = ERROR.LENGTH_ERROR
      return info
    } else {
      expList = [undefined, ...expressionList]
    }
  } else if (type === SPRING_TYPE) {
    if (len !== 6) {
      info.valid = false
      info.message = ERROR.LENGTH_ERROR
      return info
    } else {
      expList = [...expressionList]
    }
  } else { // quarts
    if (len !== 6 && len !== 7) {
      info.valid = false
      info.message = ERROR.LENGTH_ERROR
      return info
    } else {
      expList = [...expressionList]
    }
  }
  if (expList[3] === '?' && expList[5] === '?') {
    info.valid = false
    info.message = ERROR.BOTH_NOT_DESIGNATED_ERROR
    return info
  }
  const fs = [
    getSecondErrorMessage,
    getMinuteErrorMessage,
    getHourErrorMessage,
    getDayErrorMessage,
    getMonthErrorMessage,
    getWeekErrorMessage,
    getYearErrorMessage
  ]
  let errorMessage
  expList.some((exp, index) => {
    errorMessage = fs[index](exp, type)
    if (errorMessage) {
      info.valid = false
      info.message = errorMessage
      info.index = index
    }
    return errorMessage
  })
  return info
}

/** 获取秒表达式的错误信息 */
function getSecondErrorMessage (exp, type) {
  if (type !== LINUX_TYPE) { // 不是linux才校验，因为linux没有秒
    return getExpErrorMessage(exp, ['*', '-', '/', ','], 0, 59)
  }
}

/** 获取分钟表达式的错误信息 */
function getMinuteErrorMessage (exp) {
  return getExpErrorMessage(exp, ['*', '-', '/', ','], 0, 59)
}

/** 获取小时表达式的错误信息 */
function getHourErrorMessage (exp) {
  return getExpErrorMessage(exp, ['*', '-', '/', ','], 0, 23)
}

/** 获取日表达式的错误信息 */
function getDayErrorMessage (exp) {
  return getExpErrorMessage(exp, ['*', '-', '/', ',', 'NW', 'L', '?'], 1, 31)
}

/** 获取月表达式的错误信息 */
function getMonthErrorMessage (exp) {
  return getExpErrorMessage(exp, ['*', '-', '/', ','], 1, 12)
}

/** 获取周表达式的错误信息 */
function getWeekErrorMessage (exp, type) {
  const min = type === QUARTS_TYPE ? 1 : 0
  return getExpErrorMessage(exp, ['*', '-', '/', ',', '#', 'L', 'NL', '?'], min, 7)
}

/** 获取年表达式的错误信息 */
function getYearErrorMessage (exp) {
  if (exp) {
    return getExpErrorMessage(exp, ['*', '-', '/', ','], 0, 5000)
  }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-28 15:59:51
 * @Description 获取表达式的错误信息
 * @param {string} exp 一项表达式，如秒的表达式
 * @param {Array<string>} list 需要验证的类型。来源与parseExp的取值的type
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @return {string | undefined} 没有错误信息则返回undefined
 */
function getExpErrorMessage (exp, list, min, max) {
  const info = parseExp(exp)
  if (!info) { // 表示没有任何匹配
    return ERROR.FORMATTER_ERROR
  } else {
    if (list.includes(info.type)) { // 是所属类型
      return getInfoErrorMessage(info, min, max)
    } else { // 不是所属类型
      return '不支持该类型'
    }
  }
}

/**
 * @Author jiangzhiwei
 * @Date 2023-07-28 15:58:08
 * @Description 获取表达式的错误信息
 * @param {{ type: string, value?: number | Array<number>}} info
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @return {string | undefined} 没有错误信息则返回undefined
 */
function getInfoErrorMessage (info, min, max) {
  if (info.type === '-') { // 从n1到n2执行
    const num1 = info.value[0]
    const num2 = info.value[1]
    if (num1 < min) {
      return `第一个数字(${num1})小于${min}`
    } else if (num1 > num2) {
      return `第一个数字(${num1})大于第二个数字(${num2})`
    } else if (num2 > max) {
      return `第二个数字(${num2})大于${max}`
    }
  } else if (info.type === '/') { // 从n1开始，每n2执行
    const num1 = info.value[0]
    const num2 = info.value[1]
    if (num1 < min) {
      return `第一个数字(${num1})小于${min}`
    } else if (num1 > max) {
      return `第一个数字(${num1})大于${max}`
    } else if (num2 < 1) {
      return `第二个数字(${num2})小于1`
    } else if (num2 > max) {
      return `第二个数字(${num2})大于${max}`
    }
  } else if (info.type === ',') { // 指定执行
    const num1 = info.value[0]
    const num2 = info.value[info.value.length - 1]
    if (num1 < min) {
      return `有数字(${num1})小于${min}`
    } else if (num2 > max) {
      return `有数字(${num2})大于${max}`
    }
  } else if (info.type === 'NL') { // 最后一个周几
    const num = info.value
    if (num < min) {
      return `数字(${num})小于${min}`
    } else if (num > max) {
      return `数字(${num})大于${max}`
    }
  } else if (info.type === 'NW') { // 最近工作日
    const num = info.value
    if (num < min) {
      return `数字(${num})小于${min}`
    } else if (num > max) {
      return `数字(${num})大于${max}`
    }
  } else if (info.type === '#') { // 第n2个周n1
    const num1 = info.value[0]
    const num2 = info.value[1]
    if (num1 < min) {
      return `第一个数字(${num1})小于${min}`
    } else if (num1 > max) {
      return `第一个数字(${num1})大于${max}`
    } else if (num2 < 1) {
      return `第二个数字(${num2})小于1`
    } else if (num2 > 5) {
      return `第二个数字(${num2})大于5`
    }
  }
}
